home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / game / shoot / ADoomPPC_src.lha / ADoomPPC_src / w_wad.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-14  |  11.4 KB  |  629 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    Handles WAD file header, directory, lump I/O.
  21. //
  22. //-----------------------------------------------------------------------------
  23.  
  24.  
  25. static const char
  26. rcsid[] = "$Id: w_wad.c,v 1.5 1997/02/03 16:47:57 b1 Exp $";
  27.  
  28.  
  29. #ifdef NORMALUNIX
  30. #if !defined(__SASC) && !defined(__GNUC__) && !defined(__VBCC__)
  31. #include <ctype.h>
  32. #include <sys/types.h>
  33. #include <string.h>
  34. #include <unistd.h>
  35. #include <malloc.h>
  36. #include <fcntl.h>
  37. #include <sys/stat.h>
  38. #include <alloca.h>
  39. #define O_BINARY 0
  40. #else
  41. #include <stdio.h>
  42. #include <stdlib.h>
  43. #include <string.h>
  44. #include <ctype.h>
  45. #ifdef __GNUC__
  46. #include <sys/stat.h>
  47. #elif !defined(__VBCC__)
  48. #include <stat.h>
  49. #endif
  50. #endif
  51. #endif
  52.  
  53.  
  54. #include "doomdef.h"
  55. #include "doomtype.h"
  56. #include "m_swap.h"
  57. #include "i_system.h"
  58. #include "z_zone.h"
  59.  
  60. #ifdef __GNUG__
  61. #pragma implementation "w_wad.h"
  62. #endif
  63. #include "w_wad.h"
  64.  
  65.  
  66.  
  67.  
  68. //
  69. // GLOBALS
  70. //
  71.  
  72. // Location of each lump on disk.
  73. lumpinfo_t*        lumpinfo;        
  74. int            numlumps;
  75.  
  76. void**            lumpcache;
  77.  
  78.  
  79. #if !defined(__SASC)
  80. #define strcmpi    strcasecmp
  81.  
  82. void strupr (char* s)
  83. {
  84.     while (*s) { *s = toupper(*s); s++; }
  85. }
  86. #endif
  87.  
  88. #ifdef __VBCC__
  89. int filelength (int handle)
  90. {
  91.         int size;
  92.         int oldpos;
  93.  
  94.         oldpos = ftell ((FILE *)handle);
  95.         fseek((FILE *)handle, 0, SEEK_END);
  96.         size = ftell ((FILE *)handle);
  97.         fseek ((FILE *)handle, oldpos, SEEK_SET);
  98.  
  99.         return size;
  100. }
  101. #else
  102. int filelength (int handle) 
  103. { 
  104.     struct stat    *fileinfo;
  105.     int size;
  106.     
  107.     if ((fileinfo = malloc (sizeof(struct stat))) == NULL ||
  108.         fstat (handle,fileinfo) == -1)
  109.     I_Error ("Error fstating");
  110.     size = fileinfo->st_size;
  111.     free (fileinfo);
  112.  
  113.     return size;
  114. }
  115. #endif
  116.  
  117. void
  118. ExtractFileBase
  119. ( char*        path,
  120.   char*        dest )
  121. {
  122.     char*    src;
  123.     int        length;
  124.  
  125.     src = path + strlen(path) - 1;
  126.     
  127.     // back up until a \ or the start
  128.     while (src != path
  129.        && *(src-1) != '\\'
  130.        && *(src-1) != '/')
  131.     {
  132.     src--;
  133.     }
  134.     
  135.     // copy up to eight characters
  136.     memset (dest,0,8);
  137.     length = 0;
  138.     
  139.     while (*src && *src != '.')
  140.     {
  141.     if (++length == 9)
  142.         I_Error ("Filename base of %s >8 chars",path);
  143.  
  144.     *dest++ = toupper((int)*src);
  145.         src++;
  146.     }
  147. }
  148.  
  149.  
  150.  
  151.  
  152.  
  153. //
  154. // LUMP BASED ROUTINES.
  155. //
  156.  
  157. //
  158. // W_AddFile
  159. // All files are optional, but at least one file must be
  160. //  found (PWAD, if all required lumps are present).
  161. // Files with a .wad extension are wadlink files
  162. //  with multiple lumps.
  163. // Other files are single lumps with the base filename
  164. //  for the lump name.
  165. //
  166. // If filename starts with a tilde, the file is handled
  167. //  specially to allow map reloads.
  168. // But: the reload feature is a fragile hack...
  169.  
  170. int            reloadlump;
  171. char*            reloadname;
  172.  
  173.  
  174. void W_AddFile (char *filename)
  175. {
  176.     wadinfo_t        header;
  177.     lumpinfo_t*        lump_p;
  178.     unsigned        i;
  179.     FILE        *handle;
  180.     int            length;
  181.     int            startlump;
  182.     filelump_t*        fileinfo = NULL;
  183.     filelump_t        singleinfo, *fi;
  184.     FILE        *storehandle;
  185.     int                 fileinfo_allocated = 0;
  186.     
  187.     // open the file and add to directory
  188.  
  189.     // handle reload indicator.
  190.     if (filename[0] == '~')
  191.     {
  192.     filename++;
  193.     reloadname = filename;
  194.     reloadlump = numlumps;
  195.     }
  196.         
  197.     if ( (handle = fopen (filename,"r")) == NULL)
  198.     {
  199.     printf (" couldn't open %s\n",filename);
  200.     return;
  201.     }
  202.  
  203.     printf (" adding %s\n",filename);
  204.     startlump = numlumps;
  205.     
  206.     if (strcmpi (filename+strlen(filename)-3 , "wad" ) )
  207.     {
  208.     // single lump file
  209.     fileinfo = &singleinfo;
  210.     singleinfo.filepos = 0;
  211. #ifdef __VBCC__
  212.     singleinfo.size = SWAPLONG(filelength((int)handle));
  213. #else
  214.     singleinfo.size = SWAPLONG(filelength(fileno(handle)));
  215. #endif
  216.     ExtractFileBase (filename, singleinfo.name);
  217.     numlumps++;
  218.     }
  219.     else 
  220.     {
  221.     // WAD file
  222.     fread (&header, 1, sizeof(header), handle);
  223.     if (strncmp(header.identification,"IWAD",4))
  224.     {
  225.         // Homebrew levels?
  226.         if (strncmp(header.identification,"PWAD",4))
  227.         {
  228.         I_Error ("Wad file %s doesn't have IWAD "
  229.              "or PWAD id\n", filename);
  230.         }
  231.         
  232.         // ???modifiedgame = true;        
  233.     }
  234.     header.numlumps = SWAPLONG(header.numlumps);
  235.     header.infotableofs = SWAPLONG(header.infotableofs);
  236.     length = header.numlumps*sizeof(filelump_t);
  237.     fileinfo = malloc (length);
  238.         fileinfo_allocated = 1;
  239.     fseek (handle, header.infotableofs, SEEK_SET);
  240.     fread (fileinfo, 1, length, handle);
  241.     numlumps += header.numlumps;
  242.     }
  243.  
  244.     
  245.     // Fill in lumpinfo
  246.     lumpinfo = realloc (lumpinfo, numlumps*sizeof(lumpinfo_t));
  247.  
  248.     if (!lumpinfo)
  249.     I_Error ("Couldn't realloc lumpinfo");
  250.  
  251.     lump_p = &lumpinfo[startlump];
  252.     
  253.     storehandle = reloadname ? NULL : handle;
  254.  
  255.     fi = fileinfo;
  256.     for (i=startlump ; i<numlumps ; i++,lump_p++, fi++)
  257.     {
  258.     lump_p->handle = storehandle;
  259.     lump_p->position = SWAPLONG(fi->filepos);
  260.     lump_p->size = SWAPLONG(fi->size);
  261.     strncpy (lump_p->name, fi->name, 8);
  262.     }
  263.     
  264.     if (reloadname)
  265.     fclose (handle);
  266.     if (fileinfo_allocated)
  267.         free (fileinfo);
  268. }
  269.  
  270.  
  271.  
  272.  
  273. //
  274. // W_Reload
  275. // Flushes any of the reloadable lumps in memory
  276. //  and reloads the directory.
  277. //
  278. void W_Reload (void)
  279. {
  280.     wadinfo_t        header;
  281.     int            lumpcount;
  282.     lumpinfo_t*        lump_p;
  283.     unsigned        i;
  284.     FILE        *handle;
  285.     int            length;
  286.     filelump_t*        fileinfo = NULL;
  287.     filelump_t*         fi;
  288.  
  289.     if (!reloadname)
  290.     return;
  291.  
  292.     if ( (handle = fopen (reloadname,"r")) == NULL)
  293.     I_Error ("W_Reload: couldn't open %s",reloadname);
  294.  
  295.     fread (&header, 1, sizeof(header), handle);
  296.     lumpcount = SWAPLONG(header.numlumps);
  297.     header.infotableofs = SWAPLONG(header.infotableofs);
  298.     length = lumpcount*sizeof(filelump_t);
  299.     fileinfo = malloc (length);
  300.     fseek (handle, header.infotableofs, SEEK_SET);
  301.     fread (fileinfo, 1, length, handle);
  302.  
  303.     // Fill in lumpinfo
  304.     lump_p = &lumpinfo[reloadlump];
  305.     
  306.     fi = fileinfo;
  307.     for (i=reloadlump ;
  308.      i<reloadlump+lumpcount ;
  309.      i++,lump_p++, fi++)
  310.     {
  311.     if (lumpcache[i])
  312.         Z_Free (lumpcache[i]);
  313.  
  314.     lump_p->position = SWAPLONG(fi->filepos);
  315.     lump_p->size = SWAPLONG(fi->size);
  316.     }
  317.     
  318.     fclose (handle);
  319.     if (fileinfo != NULL)
  320.        free (fileinfo);
  321. }
  322.  
  323.  
  324.  
  325. //
  326. // W_InitMultipleFiles
  327. // Pass a null terminated list of files to use.
  328. // All files are optional, but at least one file
  329. //  must be found.
  330. // Files with a .wad extension are idlink files
  331. //  with multiple lumps.
  332. // Other files are single lumps with the base filename
  333. //  for the lump name.
  334. // Lump names can appear multiple times.
  335. // The name searcher looks backwards, so a later file
  336. //  does override all earlier ones.
  337. //
  338. void W_InitMultipleFiles (char** filenames)
  339. {    
  340.     int        size;
  341.     
  342.     // open all the files, load headers, and count lumps
  343.     numlumps = 0;
  344.  
  345.     // will be realloced as lumps are added
  346.     lumpinfo = malloc(1);    
  347.  
  348.     for ( ; *filenames ; filenames++)
  349.     W_AddFile (*filenames);
  350.  
  351.     if (!numlumps)
  352.     I_Error ("W_InitFiles: no files found");
  353.     
  354.     // set up caching
  355.     size = numlumps * sizeof(*lumpcache);
  356.     lumpcache = malloc (size);
  357.     
  358.     if (!lumpcache)
  359.     I_Error ("Couldn't allocate lumpcache");
  360.  
  361.     memset (lumpcache,0, size);
  362. }
  363.  
  364.  
  365.  
  366.  
  367. //
  368. // W_InitFile
  369. // Just initialize from a single file.
  370. //
  371. void W_InitFile (char* filename)
  372. {
  373.     char*    names[2];
  374.  
  375.     names[0] = filename;
  376.     names[1] = NULL;
  377.     W_InitMultipleFiles (names);
  378. }
  379.  
  380.  
  381.  
  382. //
  383. // W_NumLumps
  384. //
  385. int W_NumLumps (void)
  386. {
  387.     return numlumps;
  388. }
  389.  
  390.  
  391.  
  392. //
  393. // W_CheckNumForName
  394. // Returns -1 if name not found.
  395. //
  396.  
  397. int W_CheckNumForName (char* name)
  398. {
  399.     union {
  400.     char    s[9];
  401.     int    x[2];
  402.     
  403.     } name8;
  404.     
  405.     int        v1;
  406.     int        v2;
  407.     lumpinfo_t*    lump_p;
  408.  
  409.     // make the name into two integers for easy compares
  410.     strncpy (name8.s,name,8);
  411.  
  412.     // in case the name was a fill 8 chars
  413.     name8.s[8] = 0;
  414.  
  415.     // case insensitive
  416.     strupr (name8.s);        
  417.  
  418.     v1 = name8.x[0];
  419.     v2 = name8.x[1];
  420.  
  421.  
  422.     // scan backwards so patch lump files take precedence
  423.     lump_p = lumpinfo + numlumps;
  424.  
  425.     while (lump_p-- != lumpinfo)
  426.     {
  427.     if ( *(int *)lump_p->name == v1
  428.          && *(int *)&lump_p->name[4] == v2)
  429.     {
  430.         return lump_p - lumpinfo;
  431.     }
  432.     }
  433.  
  434.     // TFB. Not found.
  435.     return -1;
  436. }
  437.  
  438.  
  439.  
  440.  
  441. //
  442. // W_GetNumForName
  443. // Calls W_CheckNumForName, but bombs out if not found.
  444. //
  445. int W_GetNumForName (char* name)
  446. {
  447.     int    i;
  448.  
  449.     i = W_CheckNumForName (name);
  450.     
  451.     if (i == -1)
  452.       I_Error ("W_GetNumForName: %s not found!", name);
  453.       
  454.     return i;
  455. }
  456.  
  457.  
  458. //
  459. // W_LumpLength
  460. // Returns the buffer size needed to load the given lump.
  461. //
  462. int W_LumpLength (int lump)
  463. {
  464.     lumpinfo_t*    l;
  465.  
  466.     if (lump >= numlumps)
  467.     I_Error ("W_LumpLength: %i >= numlumps",lump);
  468.  
  469.     l = lumpinfo+lump;
  470.  
  471.     return l->size;    //lumpinfo[lump].size;
  472. }
  473.  
  474.  
  475.  
  476. //
  477. // W_ReadLump
  478. // Loads the lump into the given buffer,
  479. //  which must be >= W_LumpLength().
  480. //
  481. void
  482. W_ReadLump
  483. ( int        lump,
  484.   void*        dest )
  485. {
  486.     int        c;
  487.     lumpinfo_t*    l;
  488.     FILE    *handle;
  489.  
  490.     if (lump >= numlumps)
  491.     I_Error ("W_ReadLump: %i >= numlumps",lump);
  492.  
  493.     l = lumpinfo+lump;
  494.     // ??? I_BeginRead ();
  495.     
  496.     if (l->handle == NULL)
  497.     {
  498.     // reloadable file, so use open / read / close
  499.     if ( (handle = fopen (reloadname,"r")) == NULL)
  500.         I_Error ("W_ReadLump: couldn't open %s",reloadname);
  501.     }
  502.     else
  503.     handle = l->handle;
  504.     fseek (handle, l->position, SEEK_SET);
  505.       c = fread (dest, 1, l->size, handle);
  506.  
  507.     if (c < l->size)
  508.     I_Error ("W_ReadLump: only read %i of %i on lump %i",
  509.          c,l->size,lump);    
  510.  
  511.     if (l->handle == NULL)
  512.     fclose (handle);
  513.         
  514.     // ??? I_EndRead ();
  515. }
  516.  
  517.  
  518.  
  519. //
  520. // W_CacheLumpNum
  521. //
  522. void*
  523. W_CacheLumpNum
  524. ( int        lump,
  525.   int        tag )
  526. {
  527.     byte*    ptr;
  528.     int        llen;
  529.  
  530.     if ((unsigned)lump >= numlumps)
  531.     I_Error ("W_CacheLumpNum: %i >= numlumps",lump);
  532.         
  533.     if (!lumpcache[lump])
  534.     {
  535.     // read the lump in
  536.     
  537. //    printf ("cache miss on lump %i\n",lump);
  538.         llen = W_LumpLength (lump);
  539.     ptr = Z_Malloc (llen, tag, &lumpcache[lump]);
  540.         if ((ptr == NULL) || (ptr != lumpcache[lump]))
  541.           I_Error ("cache allocation error on lump %i\n",lump);
  542.     W_ReadLump (lump, lumpcache[lump]);
  543.     }
  544.     else
  545.     {
  546. //    printf ("cache hit on lump %i\n",lump);
  547.     Z_ChangeTag (lumpcache[lump],tag);    // no error checking
  548.     }
  549.     return lumpcache[lump];
  550. }
  551.  
  552.  
  553.  
  554. //
  555. // W_CacheLumpName
  556. //
  557. void*
  558. W_CacheLumpName
  559. ( char*        name,
  560.   int        tag )
  561. {
  562.     return W_CacheLumpNum (W_GetNumForName(name), tag);
  563. }
  564.  
  565.  
  566. #if 0
  567. //
  568. // W_Profile
  569. //
  570. FAR int        info[2500][10];
  571. int        profilecount;
  572.  
  573. void W_Profile (void)
  574. {
  575.     int        i;
  576.     memblock_t*    block;
  577.     void*    ptr;
  578.     char    ch;
  579.     FILE*    f;
  580.     int        j;
  581.     char    name[9];
  582.     
  583.     
  584.     for (i=0 ; i<numlumps ; i++)
  585.     {    
  586.     ptr = lumpcache[i];
  587.     if (!ptr)
  588.     {
  589.         ch = ' ';
  590.         continue;
  591.     }
  592.     else
  593.     {
  594.         block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
  595.         if (block->tag < PU_PURGELEVEL)
  596.         ch = 'S';
  597.         else
  598.         ch = 'P';
  599.     }
  600.     info[i][profilecount] = ch;
  601.     }
  602.     profilecount++;
  603.     
  604.     f = fopen ("waddump.txt","w");
  605.     name[8] = 0;
  606.  
  607.     for (i=0 ; i<numlumps ; i++)
  608.     {
  609.     memcpy (name,lumpinfo[i].name,8);
  610.  
  611.     for (j=0 ; j<8 ; j++)
  612.         if (!name[j])
  613.         break;
  614.  
  615.     for ( ; j<8 ; j++)
  616.         name[j] = ' ';
  617.  
  618.     fprintf (f,"%s ",name);
  619.  
  620.     for (j=0 ; j<profilecount ; j++)
  621.         fprintf (f,"    %c",info[i][j]);
  622.  
  623.     fprintf (f,"\n");
  624.     }
  625.     fclose (f);
  626. }
  627. #endif
  628.  
  629.